﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Drawing;

namespace Noris.Tools.FrxEditor.Pics
{
    /// <summary>
    /// Knihovna malých ikonek
    /// </summary>
    public static class IconLibraryMin
    {
        #region Image ArrowDownStd
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku arr_dn1.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu ArrowDownStd_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property ArrowDownStd, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property ArrowDownStd_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\FrxEditor\Pics\arr_dn1.png
        /// </remarks>
        public static System.Drawing.Image ArrowDownStd_Cached
        {
            get
            {
                if (_ArrowDownStd == null) _ArrowDownStd = ArrowDownStd;
                return _ArrowDownStd;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku arr_dn1.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image ArrowDownStd_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArrowDownStd_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ArrowDownStd_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\FrxEditor\Pics\arr_dn1.png
        /// </remarks>
        public static System.Drawing.Image ArrowDownStd { get { return _ImageCreateFrom(_ArrowDownStd_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru arr_dn1.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArrowDownStd_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ArrowDownStd_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\FrxEditor\Pics\arr_dn1.png
        /// </remarks>
        public static System.Drawing.Image ArrowDownStd_FromFile { get { return _ImageCreateFrom(_ArrowDownStd_string, "arr_dn1.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru ArrowDownStd
        /// </summary>
        /// <returns></returns>
        private static string _ArrowDownStd_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(244);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAAAkAAAAGCAYAAAARx7TFAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAAadEVYdFNvZnR3");
            sb.Append("YXJlAFBhaW50Lk5FVCB2My41LjEwMPRyoQAAACVJREFUGFdjYCAB/AeqxYbXo5uBrmgrLktgCnEqgGmcSoIzEUoBwPsOoysktnsAAAAASUVORK5CYII=");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property ArrowDownStd_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void ArrowDownStd_Reset()
        {
            _ArrowDownStd = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití ArrowDownStd_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _ArrowDownStd = null;
        #endregion
        #region Image ArrowDownHot
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku arr_dn2.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu ArrowDownHot_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property ArrowDownHot, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property ArrowDownHot_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\FrxEditor\Pics\arr_dn2.png
        /// </remarks>
        public static System.Drawing.Image ArrowDownHot_Cached
        {
            get
            {
                if (_ArrowDownHot == null) _ArrowDownHot = ArrowDownHot;
                return _ArrowDownHot;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku arr_dn2.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image ArrowDownHot_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArrowDownHot_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ArrowDownHot_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\FrxEditor\Pics\arr_dn2.png
        /// </remarks>
        public static System.Drawing.Image ArrowDownHot { get { return _ImageCreateFrom(_ArrowDownHot_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru arr_dn2.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArrowDownHot_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ArrowDownHot_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\FrxEditor\Pics\arr_dn2.png
        /// </remarks>
        public static System.Drawing.Image ArrowDownHot_FromFile { get { return _ImageCreateFrom(_ArrowDownHot_string, "arr_dn2.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru ArrowDownHot
        /// </summary>
        /// <returns></returns>
        private static string _ArrowDownHot_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(320);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAAAkAAAAGCAYAAAARx7TFAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAAadEVYdFNvZnR3");
            sb.Append("YXJlAFBhaW50Lk5FVCB2My41LjEwMPRyoQAAAF9JREFUGFdjaGPolgFieyAORcORiQxdEUAxRQYgocXA0P0fF25h6NQBKRIFYn9sikDiIHkGEAAy+NEVtjJ0BYLEwQpg");
            sb.Append("AFlhGkNXKpAvhKIASaEoyA31DC2SkQwxTDBxAKM7Oj8rsd+2AAAAAElFTkSuQmCC");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property ArrowDownHot_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void ArrowDownHot_Reset()
        {
            _ArrowDownHot = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití ArrowDownHot_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _ArrowDownHot = null;
        #endregion
        #region Image ArrowUpStd
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku arr_up1.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu ArrowUpStd_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property ArrowUpStd, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property ArrowUpStd_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\FrxEditor\Pics\arr_up1.png
        /// </remarks>
        public static System.Drawing.Image ArrowUpStd_Cached
        {
            get
            {
                if (_ArrowUpStd == null) _ArrowUpStd = ArrowUpStd;
                return _ArrowUpStd;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku arr_up1.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image ArrowUpStd_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArrowUpStd_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ArrowUpStd_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\FrxEditor\Pics\arr_up1.png
        /// </remarks>
        public static System.Drawing.Image ArrowUpStd { get { return _ImageCreateFrom(_ArrowUpStd_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru arr_up1.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArrowUpStd_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ArrowUpStd_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\FrxEditor\Pics\arr_up1.png
        /// </remarks>
        public static System.Drawing.Image ArrowUpStd_FromFile { get { return _ImageCreateFrom(_ArrowUpStd_string, "arr_up1.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru ArrowUpStd
        /// </summary>
        /// <returns></returns>
        private static string _ArrowUpStd_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(244);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAAAkAAAAGCAYAAAARx7TFAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAAadEVYdFNvZnR3");
            sb.Append("YXJlAFBhaW50Lk5FVCB2My41LjEwMPRyoQAAACRJREFUGFdjYCATTCWk7z9QAQhvxaUQpgCnQnQFMP56QlbD5QHUbA6jwo5LhAAAAABJRU5ErkJggg==");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property ArrowUpStd_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void ArrowUpStd_Reset()
        {
            _ArrowUpStd = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití ArrowUpStd_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _ArrowUpStd = null;
        #endregion
        #region Image ArrowUpHot
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku arr_up2.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu ArrowUpHot_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property ArrowUpHot, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property ArrowUpHot_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\FrxEditor\Pics\arr_up2.png
        /// </remarks>
        public static System.Drawing.Image ArrowUpHot_Cached
        {
            get
            {
                if (_ArrowUpHot == null) _ArrowUpHot = ArrowUpHot;
                return _ArrowUpHot;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku arr_up2.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image ArrowUpHot_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArrowUpHot_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ArrowUpHot_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\FrxEditor\Pics\arr_up2.png
        /// </remarks>
        public static System.Drawing.Image ArrowUpHot { get { return _ImageCreateFrom(_ArrowUpHot_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru arr_up2.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArrowUpHot_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ArrowUpHot_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\FrxEditor\Pics\arr_up2.png
        /// </remarks>
        public static System.Drawing.Image ArrowUpHot_FromFile { get { return _ImageCreateFrom(_ArrowUpHot_string, "arr_up2.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru ArrowUpHot
        /// </summary>
        /// <returns></returns>
        private static string _ArrowUpHot_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(328);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAAAkAAAAGCAYAAAARx7TFAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAAadEVYdFNvZnR3");
            sb.Append("YXJlAFBhaW50Lk5FVCB2My41LjEwMPRyoQAAAGVJREFUGFdjYEACbQzdoi0MnTr1DC2SkQwxTMhyYDZQAT8Q+zMwdP9PY+hKBbKFUBQhKwApAuFWhq5AkDjMBFGYCTAF");
            sb.Append("MBokDnICyBotdElkPsiNIEUyQGwPxKFoODKRoSsCKKYIAKoaOj9Xf8p4AAAAAElFTkSuQmCC");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property ArrowUpHot_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void ArrowUpHot_Reset()
        {
            _ArrowUpHot = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití ArrowUpHot_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _ArrowUpHot = null;
        #endregion
        #region Image GridCrossRed
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku GridCrossRed.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu GridCrossRed_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property GridCrossRed, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property GridCrossRed_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\FrxEditor\Pics\22\GridCrossRed.png
        /// </remarks>
        public static System.Drawing.Image GridCrossRed_Cached
        {
            get
            {
                if (_GridCrossRed == null) _GridCrossRed = GridCrossRed;
                return _GridCrossRed;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku GridCrossRed.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image GridCrossRed_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití GridCrossRed_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property GridCrossRed_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\FrxEditor\Pics\22\GridCrossRed.png
        /// </remarks>
        public static System.Drawing.Image GridCrossRed { get { return _ImageCreateFrom(_GridCrossRed_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru GridCrossRed.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití GridCrossRed_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property GridCrossRed_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\FrxEditor\Pics\22\GridCrossRed.png
        /// </remarks>
        public static System.Drawing.Image GridCrossRed_FromFile { get { return _ImageCreateFrom(_GridCrossRed_string, "GridCrossRed.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru GridCrossRed
        /// </summary>
        /// <returns></returns>
        private static string _GridCrossRed_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(232);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAAAUAAAAFCAYAAACNbyblAAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAOwgAADsIBFShKgAAAABp0RVh0U29mdHdhcmUAUGFpbnQuTkVU");
            sb.Append("IHYzLjUuMTAw9HKhAAAAKUlEQVQYV2P4//8/AxiHhhrA2BABiGADQhCkAiTAAJQD0UA+DpVYzAQAoUtB1yBhGysAAAAASUVORK5CYII=");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property GridCrossRed_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void GridCrossRed_Reset()
        {
            _GridCrossRed = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití GridCrossRed_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _GridCrossRed = null;
        #endregion
        #region Image GridCrossYellow
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku GridCrossYellow.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu GridCrossYellow_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property GridCrossYellow, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property GridCrossYellow_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\FrxEditor\Pics\22\GridCrossYellow.png
        /// </remarks>
        public static System.Drawing.Image GridCrossYellow_Cached
        {
            get
            {
                if (_GridCrossYellow == null) _GridCrossYellow = GridCrossYellow;
                return _GridCrossYellow;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku GridCrossYellow.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image GridCrossYellow_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití GridCrossYellow_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property GridCrossYellow_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\FrxEditor\Pics\22\GridCrossYellow.png
        /// </remarks>
        public static System.Drawing.Image GridCrossYellow { get { return _ImageCreateFrom(_GridCrossYellow_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru GridCrossYellow.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití GridCrossYellow_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property GridCrossYellow_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\FrxEditor\Pics\22\GridCrossYellow.png
        /// </remarks>
        public static System.Drawing.Image GridCrossYellow_FromFile { get { return _ImageCreateFrom(_GridCrossYellow_string, "GridCrossYellow.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru GridCrossYellow
        /// </summary>
        /// <returns></returns>
        private static string _GridCrossYellow_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(232);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAAAMAAAADCAYAAABWKLW/AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAAadEVYdFNvZnR3");
            sb.Append("YXJlAFBhaW50Lk5FVCB2My41LjEwMPRyoQAAAB1JREFUGFdj+P//P8OZ/+UNIBrCuMvwH0QzIMsAAAFmGdhfMW7FAAAAAElFTkSuQmCC");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property GridCrossYellow_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void GridCrossYellow_Reset()
        {
            _GridCrossYellow = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití GridCrossYellow_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _GridCrossYellow = null;
        #endregion
        #region Cursor Cross_r_doc
        /// <summary>
        /// Vrátí cursor, načtený ze souboru cross_r_doc.cur.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu Cross_r_doc_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property Cross_r_doc, která vrací vždy nový objekt.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\FrxEditor\Pics\cur\cross_r_doc.cur
        /// </remarks>
        public static System.Windows.Forms.Cursor Cross_r_doc_Direct
        {
            get
            {
                if (_Cross_r_doc != null) return _Cross_r_doc;
                _Cross_r_doc = Cross_r_doc;
                return _Cross_r_doc;
            }
        }
        /// <summary>
        /// Vrátí cursor, načtený ze souboru cross_r_doc.cur.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Cross_r_doc_Direct 
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho objektu Cursor (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat cursor často a rychle, je možné využít property Cross_r_doc_Direct.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\FrxEditor\Pics\cur\cross_r_doc.cur
        /// </remarks>
        public static System.Windows.Forms.Cursor Cross_r_doc
        {
            get
            {
                System.Text.StringBuilder sb = new System.Text.StringBuilder(436);
                sb.Append("AAACAAEAICAAAA8AEAAwAQAAFgAAACgAAAAgAAAAQAAAAAEAAQAAAAAAgAAAAAAAAAAAAAAAAgAAAAIAAAAAAAAA////AAAAAAAAAAAAAAAAAAAAAAAAAD/+AAAgAgAD");
                sb.Append("r/oAAqgKAAKoCgACqAoAAq/6AAKgAgACv/4AAoAAA/7/gAIAAIAD/v+AAAKAAAACgAAAAoAAAAKAAAACgAAAAoAAAAKAAAADgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA");
                sb.Append("AAAAAAAA////////////////////////wAH//8AB//xAAf/8R/H//Efx//xH8f/8QAH//EAB//xAAf/8f//8AAB//AAAf/wAAH///H////x////8f////H////x////8");
                sb.Append("f////H////x///////////////////////////////////////8=");
                return ConvertStringToCursor(sb.ToString());
            }
        }
        /// <summary>
        /// Resetuje cursor v paměti.
        /// Následující použití property Cross_r_doc_Direct si vytvoří novou, korektní - podle originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost cursoru v paměti nejistá.
        /// </summary>
        public static void Cross_r_doc_Reset()
        {
            _Cross_r_doc = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití Cross_r_doc_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Windows.Forms.Cursor _Cross_r_doc = null;
        #endregion
        #region SPOLEČNÉ METODY PRO KONVERZI
        /// <summary>
        /// Vrátí Image z definice (string). Image generuje buď v paměti, anebo s pomocí souboru.
        /// Pokud není zadán parametr (cacheFileName) (když je null), generuje se Image v paměti.
        /// Pokud je soubor (cacheFileName) definován, pak se Image čte z něj.
        /// Pokud soubor neexistuje, nejprve se vytvoří.
        /// Umístění souboru (adresář) je dán property _ImageCacheDir, defaultně je to adresář (Sys:\Documents and Settings\All Users\Data aplikací\IconCache).
        /// Obsah obrázku definuje metoda getDataMethod.
        /// </summary>
        /// <param name="getDataMethod"></param>
        /// <param name="cacheFileName"></param>
        /// <returns></returns>
        private static System.Drawing.Image _ImageCreateFrom(_GetStringDelegate getDataMethod, string cacheFileName)
        {
            System.Drawing.Image image;
            if (cacheFileName == null)
            {
                using (System.IO.MemoryStream ms = new System.IO.MemoryStream(Convert.FromBase64String(getDataMethod())))
                {
                    image = System.Drawing.Image.FromStream(ms);
                }
                return image;
            }
            string fileName = System.IO.Path.Combine(_ImageCacheDir, cacheFileName);
            if (!System.IO.File.Exists(fileName))
                System.IO.File.WriteAllBytes(fileName, Convert.FromBase64String(getDataMethod()));
            if (System.IO.File.Exists(fileName))
                return Image.FromFile(fileName);
            return null;
        }
        /// <summary>
        /// Obsahuje jméno adresáře, který slouží jako Cache pro obrázky systému.
        /// </summary>
        private static string _ImageCacheDir
        {
            get
            {
                string dirName = System.IO.Path.Combine(System.Environment.GetFolderPath(System.Environment.SpecialFolder.CommonApplicationData), "Editor\\IconCacheMin");
                if (!System.IO.Directory.Exists(dirName))
                    System.IO.Directory.CreateDirectory(dirName);
                return dirName;
            }
        }
        /// <summary>
        /// Předpis pro metody, které generují obsah souboru s daty
        /// </summary>
        /// <returns></returns>
        private delegate string _GetStringDelegate();
        /// <summary>
        /// Vrátí Icon z dat (string), která jsou předána na vstup v kódování Base64
        /// </summary>
        /// <param name="data">Vstupní data v kódování Base64</param>
        /// <returns>Icon vytvořená z dat</returns>
        public static System.Drawing.Icon ConvertStringToIcon(string data)
        {
            System.Drawing.Icon icon;
            using (System.IO.MemoryStream ms = new System.IO.MemoryStream(Convert.FromBase64String(data)))
            {
                icon = new System.Drawing.Icon(ms);
            }
            return icon;
        }
        /// <summary>
        /// Vrátí Cursor z dat (string), která jsou předána na vstup v kódování Base64
        /// </summary>
        /// <param name="data">Vstupní data v kódování Base64</param>
        /// <returns>Cursor vytvořený z dat</returns>
        public static System.Windows.Forms.Cursor ConvertStringToCursor(string data)
        {
            System.Windows.Forms.Cursor cursor;
            using (System.IO.MemoryStream ms = new System.IO.MemoryStream(Convert.FromBase64String(data)))
            {
                cursor = new System.Windows.Forms.Cursor(ms);
            }
            return cursor;
        }
        #endregion
    }
}
